<?xml version="1.0"?>
<doc>
    <assembly>
        <name>BigfootSQL</name>
    </assembly>
    <members>
        <member name="T:BigfootSQL.Json.JavaScriptArray">
            <summary>
            Represents a JavaScript array.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptArray.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JavaScriptObject"/> class.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptArray.#ctor(System.Collections.Generic.IEnumerable{System.Object})">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JavaScriptArray"/> class that
            contains elements copied from the specified collection.
            </summary>
            <param name="collection">The collection whose elements are copied to the new array.</param>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptArray.#ctor(System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JavaScriptArray"/> class that
            is empty and has the specified initial capacity.
            </summary>
            <param name="capacity">The number of elements that the new array can initially store.</param>
        </member>
        <!-- Badly formed XML comment ignored for member "T:BigfootSQL.SqlHelper" -->
        <member name="M:BigfootSQL.SqlHelper.Add(System.String)">
            <summary>
            Add literal SQL statement to the query
            </summary>
            <param name="sql">SQL Fragment to add</param>
        </member>
        <member name="M:BigfootSQL.SqlHelper.Add(System.String,System.Object)">
            <summary>
            Add a parameter to a WHERE statement. Will generate ColumnName = 'Value' (quotes only added if it is a string)
            </summary>
            <param name="wherecolumn">The name of the column to search</param>
            <param name="value">The value to search for</param>
        </member>
        <member name="M:BigfootSQL.SqlHelper.Add(System.String,System.Object,System.Boolean)">
            <summary>
            Add a paramter to a WHERE statement. Will generate ColumnName {Operator} 'Value' (quotes only added if it is a string)
            </summary>
            <param name="wherecolumn">The of the column to search</param>
            <param name="value">The value to search for. If it is a string it is properly espaped etc.</param>
            /// <param name="isSet">Identifies this comparison as a set statement. Needed for setting null values</param>
        </member>
        <!-- Badly formed XML comment ignored for member "M:BigfootSQL.SqlHelper.Add(System.String,System.String,System.Object)" -->
        <!-- Badly formed XML comment ignored for member "M:BigfootSQL.SqlHelper.Add(System.String,System.String,System.Object,System.Boolean)" -->
        <member name="M:BigfootSQL.SqlHelper.SELECTPAGED(System.String,System.String,System.Int32)">
            <summary>
            Used to returned a paged result set
            </summary>
            <param name="columns">Columns to include in the paged result. When paging this you can specify columns only once</param>
            <param name="pageorderby">This is used to generate the RowNumber field resulting in: 
            ROW_NUMBER() OVER(ORDER BY Field1, Field2) AS RowNumber </param>
            <param name="pageSize">How many records per page</param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.PAGE(System.Int32)">
            <summary>
            Call this function to identify which page to get. Must be called at the end of the statement.
            </summary>
            <param name="currentpage">The current page (0 based)</param>
        </member>
        <member name="M:BigfootSQL.SqlHelper.EXECUTE(System.String,System.Object[])">
            <summary>
            Execute a StoredProcedure. By passing the SP name and a list values as parameters to the SP
            </summary>
            <param name="spname">SP Name</param>
            <param name="ps">Parameters for the Stored Procedure in the proper order</param>
        </member>
        <member name="M:BigfootSQL.SqlHelper.SELECT_SCALARFUNCTION(System.String,System.Object[])">
            <summary>
            Execute a function by passing the function anem of and a list of paremters. 
            e.g. SELECT_SCALARFUNCTION("GetOrderName", OrderDate, CustomerID)
            </summary>
            <param name="fname">Name of the function</param>
            <param name="ps">List of parameters values to pass into the function. Must be in the right order</param>
        </member>
        <member name="M:BigfootSQL.SqlHelper.AddTempParam(System.Object)">
            <summary>
            Adds a parameter with the provided value and returns the created parameter name
            Used when creating dynamic queries and the parameter is not important outside of the inmediate query
            Used internally to auto created parameters for the WHERE AND OR and other statements
            </summary>
            <param name="value">The value of the parameter</param>
            <returns>The generated name for the parameter</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.AddParam(System.String,System.Object)">
            <summary>
            Adds a named parameter to the query
            </summary>
            <param name="name">The name of the parameter</param>
            <param name="value">The value of the paremter</param>
        </member>
        <member name="M:BigfootSQL.SqlHelper.Clear">
            <summary>
            Clear the current query
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ToString">
            <summary>
            Auto writes the finished statement as close as possible.
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelper.Translate(System.String)">
            <summary>
            Used to support DotNetNuke queries where database object names
            are dynamic based on the prefix of the installation.
            By using {{{TableName}}} it will translate into a proper DNN core table name
            By using {{TableName}} it will translate into a proper custom DNN Module table name
            </summary>
            <param name="sql">The sql fragment to translate</param>
            <returns>The translated string</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ArrayToINint(System.Int32[])">
            <summary>
            Converts a collection of int into a value list to be used in and IN statement
            </summary>
            <param name="ps">List of int values</param>
            <returns>Properly formatted list for IN statement</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.EscapeApostrophe(System.String)">
            <summary>
            Escapes the apostrophe on strings
            </summary>
            <param name="sql">SQL statement fragment</param>
            <returns>The clean SQL fragment</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.EscapeForLike(System.String,System.Boolean)">
            <summary>
            Properly excapes a string to be included in a LIKE statement
            </summary>
            <param name="value">Value to search for</param>
            <param name="escapeApostrophe">Weather to escape the apostrophe. Prevents double escaping of apostrophes</param>
            <returns>The transalted value ready to be used in a LIKE statement</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.GetTokens(System.String,System.String,System.String)">
            <summary>
            Retreives a list of tokens included in a string
            </summary>
            <param name="s">The string object being exteded</param>
            <param name="startDelimiter">The start delimiter for the token</param>
            <param name="endDelimiter">The end delimiter for the token</param>
            <returns>A dictionary of tokens present in the string</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.GetTokens(System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.String,System.String)">
            <summary>
            Retreives a list of tokens included in a string
            </summary>
            <param name="s">The string object being exteded</param>
            <param name="startDelimiter">The start delimiter for the token</param>
            <param name="endDelimiter">The end delimiter for the token</param>
            <param name="tokens">The dictionary of tokens to add the new finds to</param>
            <returns>A dictionary of tokens present in the string</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteScalar">
            <summary>
            Executes the query and returns a Scalar value
            </summary>
            <returns>Object (null when dbnull value is returned)</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteScalar``1">
            <summary>
            Executes the query and returns a Scalar value for the specific generic value
            </summary>
            <returns>A typed object of T</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteScalarIdentity">
            <summary>
            Appends a SELECT @@IDENTITY statement to the query and then executes
            </summary>
            <returns>The identity of the just inserted record</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteScalarInt">
            <summary>
            Executes the query and returns a sclar value of type int
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteScalarString">
            <summary>
            Executes the query and returns a sclar value of type string
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteNonquery">
            <summary>
            Executes a query that does not return a value
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteObject``1">
            <summary>
            Executes a query and hydrates an object with the result
            </summary>
            <typeparam name="T">The type of the object to hydrate and return</typeparam>
            <returns>I hydrated object of the type specified</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteValues">
            <summary>
            Returns a dictionary of FieldName. Works like Scalar except it can 
            return multiple fields values for the first record of the resultset
            </summary>
            <returns>Dictionary with FieldName, Value</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteStringCollection">
            <summary>
            Executes the query and returnes a collection of strings. 
            Useful when needing a quick lookup set of values
            </summary>
            <returns>A string collection</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteCollection``1">
            <summary>
            Executes the query and maps the results to a collection of objects 
            of the type specified through the generic argument
            </summary>
            <typeparam name="T">The of object for the collection</typeparam>
            <returns>A collection of T</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteReader">
            <summary>
            Executes the query and returns a DataReader
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteDataset">
            <summary>
            Executes the query and returns a filled Dataset with the resultset
            </summary>
            <returns>A dataset</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.ExecuteDataset(System.Data.DataSet)">
            <summary>
            Executes ther query and adds the results to the provided dataset
            </summary>
            <param name="data">The dataset to fill with this query</param>
            <returns>The dataset passed in</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.AddTypeConverter(System.String,BigfootSQL.SqlHelper.ITypeConverter)">
            <summary>
            Adds a custom type converter. When hydrating an object, certain complex types might have special needs 
            when it comes to deserializing from database. You can add a customer converter for the type, in order to 
            have the auto hydration use the this type converter instead of the Default type converter
            </summary>
            <param name="typeName">Full name of the type to use the converter for</param>
            <param name="converter">The converter oject to use. It must implement the ITypeConverter interface</param>
        </member>
        <member name="M:BigfootSQL.SqlHelper.GetAllConverters">
            <summary>
            Retreives a list of ITypeConverters in the system
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelper.GetTypeConverter(System.String)">
            <summary>
            Gets the database value converter for a certain Type name
            </summary>
            <param name="typeName">The full name of the type e.g. System.String</param>
            <returns>A ITypeConverter object from the cache</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.GetValue(System.Type,System.Object)">
            <summary>
            Converts a database value to its object representation. Uses the TypeConverter cache to properly translate complex types
            </summary>
            <param name="fieldType">The Type of the field to convert to</param>
            <param name="value">The database value. e.g. the object from the data reader ordinal</param>
            <returns>A properly converted object</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.FillObject``1(System.Data.IDataReader)">
            <summary>
            Fills an object using generics from a data reader object
            </summary>
            <typeparam name="T">The type of the object to fill</typeparam>
            <param name="dr">The data reader object used to hydrate the object</param>
            <returns>A hydrated object of type T</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.FillCollection``1(System.Data.SqlClient.SqlDataReader)">
            <summary>
            Fills a collection of objects using generics from a data reader object
            </summary>
            <typeparam name="T">The Type of the collection item object to fill</typeparam>
            <param name="reader">The reader object used to hydrate the collection</param>
            <returns>Collection of type of type T</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.FillObject``1(System.Data.IDataReader,System.Boolean)">
            <summary>
            Fill a particular object
            </summary>
            <typeparam name="T">The type of object to fill</typeparam>
            <param name="dr">The reader object used to hydrate the object</param>
            <param name="manageDataReader">When set to true, closes the reader when finished</param>
            <returns>A hydrated object of type T</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.GetOrdinals(System.Collections.Generic.List{System.Object},System.Data.IDataReader)">
            <summary>
            Match the bject fields against the ordinal of the DataReader. The ordinal of the DataReader is used 
            Rather than the string indexer to maximize performance
            </summary>
            <param name="fields">The list of members to hydrate for the object</param>
            <param name="dr">The data reader to map the ordinals from</param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.SqlHelper.GetFields(System.Object)">
            <summary>
            Get the fields / properties to hydrate for an object. 
            Caches the object map in order to maximize performance. 
            So reflection is used only first time on n object type
            </summary>
            <param name="obj">Object to use to hydrate</param>
            <returns>A list of Fields and Properties</returns>
        </member>
        <member name="P:BigfootSQL.SqlHelper.DebugSql">
            <summary>
            Creates an executable SQL statement including declaration of SQL parameters for debugging purposes.
            </summary>
        </member>
        <member name="T:BigfootSQL.SqlHelper.Cache">
            <summary>
            Generic cache class to cache object graphs and type converters
            </summary>
        </member>
        <member name="T:BigfootSQL.DAAB">
            <summary>
            The DAAB class is intended to encapsulate high performance, scalable best practices for 
            common uses of SqlClient
            </summary>
        </member>
        <member name="M:BigfootSQL.DAAB.AttachParameters(System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlParameter[])">
            <summary>
            This method is used to attach array of SqlParameters to a SqlCommand.
            
            This method will assign a value of DbNull to any parameter with a direction of
            InputOutput and a value of null.  
            
            This behavior will prevent default values from being used, but
            this will be the less common case than an intended pure output parameter (derived as InputOutput)
            where the user provided no input value.
            </summary>
            <param name="command">The command to which the parameters will be added</param>
            <param name="commandParameters">An array of SqlParameters to be added to command</param>
        </member>
        <member name="M:BigfootSQL.DAAB.AssignParameterValues(System.Data.SqlClient.SqlParameter[],System.Data.DataRow)">
            <summary>
            This method assigns dataRow column values to an array of SqlParameters
            </summary>
            <param name="commandParameters">Array of SqlParameters to be assigned values</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>
        </member>
        <member name="M:BigfootSQL.DAAB.AssignParameterValues(System.Data.SqlClient.SqlParameter[],System.Object[])">
            <summary>
            This method assigns an array of values to an array of SqlParameters
            </summary>
            <param name="commandParameters">Array of SqlParameters to be assigned values</param>
            <param name="parameterValues">Array of objects holding the values to be assigned</param>
        </member>
        <member name="M:BigfootSQL.DAAB.PrepareCommand(System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[],System.Boolean@)">
            <summary>
            This method opens (if necessary) and assigns a connection, transaction, command type and parameters 
            to the provided command
            </summary>
            <param name="command">The SqlCommand to be prepared</param>
            <param name="connection">A valid SqlConnection, on which to execute this command</param>
            <param name="transaction">A valid SqlTransaction, or 'null'</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParameters to be associated with the command or 'null' if no parameters are required</param>
            <param name="mustCloseConnection"><c>true</c> if the connection was opened by the method, otherwose is false.</param>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns no resultset and takes no parameters) against the database specified in 
            the connection string
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
            using the provided parameters
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored prcedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns no resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns no resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQuery(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDataset(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[],BigfootSQL.DAAB.SqlConnectionOwnership)">
            <summary>
            Create and prepare a SqlCommand, and call ExecuteReader with the appropriate CommandBehavior.
            </summary>
            <remarks>
            If we created and opened the connection, we want the connection to be closed when the DataReader is closed.
            
            If the caller provided the connection, we want to leave it to them to manage.
            </remarks>
            <param name="connection">A valid SqlConnection, on which to execute this command</param>
            <param name="transaction">A valid SqlTransaction, or 'null'</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParameters to be associated with the command or 'null' if no parameters are required</param>
            <param name="connectionOwnership">Indicates whether the connection parameter was provided by the caller, or created by DAAB</param>
            <returns>SqlDataReader containing the results of the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
              SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReader(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalar(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReader(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure using "FOR XML AUTO"</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReader(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.String,System.Data.CommandType,System.String,System.Data.DataSet,System.String[])">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)</param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.String,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.String,System.String,System.Data.DataSet,System.String[],System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>    
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.DataSet,System.String[])">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>    
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataSet,System.String[],System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.DataSet,System.String[])">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataSet,System.String[],System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        </member>
        <member name="M:BigfootSQL.DAAB.FillDataset(System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Private helper method that execute a SqlCommand (that returns a resultset) against the specified SqlTransaction and SqlConnection
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        </member>
        <member name="M:BigfootSQL.DAAB.UpdateDataset(System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlCommand,System.Data.DataSet,System.String)">
            <summary>
            Executes the respective command for each inserted, updated, or deleted row in the DataSet.
            </summary>
            <remarks>
            e.g.:  
             UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
            </remarks>
            <param name="insertCommand">A valid transact-SQL statement or stored procedure to insert new records into the data source</param>
            <param name="deleteCommand">A valid transact-SQL statement or stored procedure to delete records from the data source</param>
            <param name="updateCommand">A valid transact-SQL statement or stored procedure used to update records in the data source</param>
            <param name="dataSet">The DataSet used to update the data source</param>
            <param name="tableName">The DataTable used to update the data source.</param>
        </member>
        <member name="M:BigfootSQL.DAAB.CreateCommand(System.Data.SqlClient.SqlConnection,System.String,System.String[])">
            <summary>
            Simplify the creation of a Sql command object by allowing
            a stored procedure and optional parameters to be provided
            </summary>
            <remarks>
            e.g.:  
             SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
            </remarks>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="sourceColumns">An array of string to be assigned as the source columns of the stored procedure parameters</param>
            <returns>A valid SqlCommand object</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQueryTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQueryTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.  
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteNonQueryTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified
            SqlTransaction using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDatasetTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDatasetTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the dataRow column values as the store procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteDatasetTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReaderTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReaderTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteReaderTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalarTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalarTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteScalarTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReaderTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:BigfootSQL.DAAB.ExecuteXmlReaderTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="T:BigfootSQL.DAAB.SqlConnectionOwnership">
            <summary>
            This enum is used to indicate whether the connection was provided by the caller, or created by DAAB, so that
            we can set the appropriate CommandBehavior when calling ExecuteReader()
            </summary>
        </member>
        <member name="F:BigfootSQL.DAAB.SqlConnectionOwnership.Internal">
            <summary>Connection is owned and managed by DAAB</summary>
        </member>
        <member name="F:BigfootSQL.DAAB.SqlConnectionOwnership.External">
            <summary>Connection is owned and managed by the caller</summary>
        </member>
        <member name="T:BigfootSQL.SqlHelperParameterCache">
            <summary>
            SqlHelperParameterCache provides functions to leverage a static cache of procedure parameters, and the
            ability to discover parameters for stored procedures at run-time.
            </summary>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.DiscoverSpParameterSet(System.Data.SqlClient.SqlConnection,System.String,System.Boolean)">
            <summary>
            Resolve at run time the appropriate set of SqlParameters for a stored procedure
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">Whether or not to include their return value parameter</param>
            <returns>The parameter array discovered.</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.CloneParameters(System.Data.SqlClient.SqlParameter[])">
            <summary>
            Deep copy of cached SqlParameter array
            </summary>
            <param name="originalParameters"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.CacheParameterSet(System.String,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Add parameter array to the cache
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters to be cached</param>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.GetCachedParameterSet(System.String,System.String)">
            <summary>
            Retrieve a parameter array from the cache
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An array of SqlParamters</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.GetSpParameterSet(System.String,System.String)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.GetSpParameterSet(System.String,System.String,System.Boolean)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.GetSpParameterSet(System.Data.SqlClient.SqlConnection,System.String)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.GetSpParameterSet(System.Data.SqlClient.SqlConnection,System.String,System.Boolean)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:BigfootSQL.SqlHelperParameterCache.GetSpParameterSetInternal(System.Data.SqlClient.SqlConnection,System.String,System.Boolean)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="T:BigfootSQL.Validation.DateValidator">
            ********************************************************************
            <summary>
            Date validation handlers.
            </summary>
        </member>
        <member name="T:BigfootSQL.Validation.ValidatorBase`2">
            ********************************************************************
            <summary>
            This class serves as the base for a creating a validator for a
            particular data type. It provides various common utilities.
            </summary>
            <typeparam name="TValue">
            </typeparam>
        </member>
        <member name="M:BigfootSQL.Validation.ValidatorBase`2.#ctor(`1,System.String,BigfootSQL.Validation.Validator)">
            ********************************************************************
            <summary>
            Constructor.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <param name="validatorObj"></param>
        </member>
        <member name="F:BigfootSQL.Validation.ValidatorBase`2.NextFailureResultLevel">
            <summary>
            The level of the next failure.
            </summary>
        </member>
        <member name="F:BigfootSQL.Validation.ValidatorBase`2.NextErrorCode">
            <summary>
            The code of the next error.
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.ValidatorBase`2.SetResult(System.Boolean,System.String)">
            ********************************************************************
            <summary>
            Set the result of a check.
            </summary>
            <param name="Result"></param>
            <param name="ErrorMsg"></param>
        </member>
        <member name="M:BigfootSQL.Validation.ValidatorBase`2.SetResult(System.Boolean,System.String,System.Int32)">
            ********************************************************************
            <summary>
            Set the result of a check.
            </summary>
            <param name="Result"></param>
            <param name="ErrorMsg"></param>
            <param name="ErrorCode"></param>
        </member>
        <member name="M:BigfootSQL.Validation.ValidatorBase`2.Not">
            ********************************************************************
            <summary>
            Negates the next validation check.
            </summary>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.ValidatorBase`2.WarnUnless">
            ********************************************************************
            <summary>
            Sets the level of the next validation result to just be warning,
            rather than error.
            </summary>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.ValidatorBase`2.WithErrorCode(System.Int32)">
            ********************************************************************
            <summary>
            Sets the code for the next validation result.
            </summary>
            <returns></returns>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorBase`2.Value">
            ********************************************************************
            <summary>
            return the value property
            </summary>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorBase`2.FieldName">
            <summary>
            The name of the field being tested
            </summary>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorBase`2.ValidatorObj">
            <summary>
            Reference to our validator caller class.
            </summary>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorBase`2.NegateNextValidationResult">
            <summary>
            TRUE if the next validation operation should be negated
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.#ctor(System.DateTime,System.String,BigfootSQL.Validation.Validator)">
            ********************************************************************
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Validation.DateValidator"/> class. 
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <param name="validatorObj"></param>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsNotAFutureDate(System.String)">
            *****************************************************************
            <summary>
            Checks that the date provided is not in the future (has a date
            part that is later than today).
            </summary>
            <param name="errorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsNotAFutureDate">
            <summary>
            Checks that the date provided is not in the future (has a date
            part that is not later than today).
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsNotAPastDate(System.String)">
            *****************************************************************
            <summary>
            Checks that the date provided is not in the past (has a date part
            that is not earlier than today).
            </summary>
            <param name="errorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsNotAPastDate">
            <summary>
            Checks that the date provided is not in the past (has a date part
            that is not earlier than today).
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsNotMinMaxValue(System.String)">
            *****************************************************************
            <summary>
            Checks that the date is not DateTime.Min or DateTime.Max.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsNotMinMaxValue">
            <summary>
            Checks that the date is not DateTime.Min or DateTime.Max.
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsEarlierThan(System.DateTime,System.String)">
            *****************************************************************
            <summary>
            Checks that the date is ealier than the provided check date.
            </summary>
            <param name="CheckDateValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsEarlierThan(System.DateTime)">
            <summary>
            Checks that the date is ealier than the provided check date.
            </summary>
            <param name="CheckDateValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsLaterThan(System.DateTime,System.String)">
            *****************************************************************
            <summary>
            Checks that the date is later than the provided check date.
            </summary>
            <param name="CheckDateValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.DateValidator.IsLaterThan(System.DateTime)">
            <summary>
            Checks that the date is later than the provided check date.
            </summary>
            <param name="CheckDateValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="T:BigfootSQL.Validation.ValidatorResult">
            ****************************************************************
            <summary>
            Represents a validation failutre.
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.ValidatorResult.#ctor(System.String,System.String,BigfootSQL.Validation.ValidatorResultLevel,System.Int32)">
            ******************************************************************
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Validation.ValidatorResult">class</see>. 
            </summary>
            <param name="ErrorMessage"></param>
            <param name="fieldName"></param>
            <param name="level"></param>
            <param name="errorCode"></param>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorResult.ValidationMessage">
            <summary>
            The error message
            </summary>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorResult.FieldName">
            <summary>
            The field name that caused the error
            </summary>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorResult.Level">
            <summary>
            Validation failure level; is it an error or warning?
            </summary>
        </member>
        <member name="P:BigfootSQL.Validation.ValidatorResult.ErrorCode">
            <summary>
            Validation error code, as defined in <see>ErrorCodes</see>.
            </summary>
        </member>
        <member name="T:BigfootSQL.Validation.ValidationErrorCode">
            <summary>
            Default error codes for the various validation failures that we can get.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.WriteState">
            <summary>
            Specifies the state of the <see cref="T:BigfootSQL.Json.JsonWriter"/>.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.WriteState.Error">
            <summary>
            An exception has been thrown, which has left the <see cref="T:BigfootSQL.Json.JsonWriter"/> in an invalid state.
            You may call the <see cref="M:BigfootSQL.Json.JsonWriter.Close"/> method to put the <see cref="T:BigfootSQL.Json.JsonWriter"/> in the <c>Closed</c> state.
            Any other <see cref="T:BigfootSQL.Json.JsonWriter"/> method calls results in an <see cref="T:System.InvalidOperationException"/> being thrown. 
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.WriteState.Closed">
            <summary>
            The <see cref="M:BigfootSQL.Json.JsonWriter.Close"/> method has been called. 
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.WriteState.Object">
            <summary>
            An object is being written. 
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.WriteState.Array">
            <summary>
            A array is being written.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.WriteState.Property">
            <summary>
            A property is being written.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.WriteState.Start">
            <summary>
            A write method has not been called.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.Formatting">
            <summary>
            Specifies formatting options for the <see cref="T:BigfootSQL.Json.JsonWriter"/>.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.Formatting.None">
            <summary>
            No special formatting is applied. This is the default.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.Formatting.Indented">
            <summary>
            Causes child objects to be indented according to the <see cref="P:BigfootSQL.Json.JsonWriter.Indentation"/> and <see cref="P:BigfootSQL.Json.JsonWriter.IndentChar"/> settings.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.JsonWriter">
            <summary>
            Represents a writer that provides a fast, non-cached, forward-only way of generating Json data.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.#ctor(System.IO.TextWriter)">
            <summary>
            Creates an instance of the <c>JsonWriter</c> class using the specified <see cref="T:System.IO.TextWriter"/>. 
            </summary>
            <param name="textWriter">The <c>TextWriter</c> to write to.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.Flush">
            <summary>
            Flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.Close">
            <summary>
            Closes this stream and the underlying stream.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteStartObject">
            <summary>
            Writes the beginning of a Json object.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteEndObject">
            <summary>
            Writes the end of a Json object.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteStartArray">
            <summary>
            Writes the beginning of a Json array.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteEndArray">
            <summary>
            Writes the end of an array.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WritePropertyName(System.String)">
            <summary>
            Writes the property name of a name/value pair on a Json object.
            </summary>
            <param name="name"></param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteEnd">
            <summary>
            Writes the end of the current Json object or array.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteNull">
            <summary>
            Writes a null value.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteUndefined">
            <summary>
            Writes an undefined value.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteRaw(System.String)">
            <summary>
            Writes raw JavaScript manually.
            </summary>
            <param name="javaScript">The raw JavaScript to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.String)">
            <summary>
            Writes a <see cref="T:System.String"/> value.
            </summary>
            <param name="value">The <see cref="T:System.String"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Int32)">
            <summary>
            Writes a <see cref="T:System.Int32"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Int32"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.UInt32)">
            <summary>
            Writes a <see cref="T:System.UInt32"/> value.
            </summary>
            <param name="value">The <see cref="T:System.UInt32"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Int64)">
            <summary>
            Writes a <see cref="T:System.Int64"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Int64"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.UInt64)">
            <summary>
            Writes a <see cref="T:System.UInt64"/> value.
            </summary>
            <param name="value">The <see cref="T:System.UInt64"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Single)">
            <summary>
            Writes a <see cref="T:System.Single"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Single"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Double)">
            <summary>
            Writes a <see cref="T:System.Double"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Double"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Boolean)">
            <summary>
            Writes a <see cref="T:System.Boolean"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Boolean"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Int16)">
            <summary>
            Writes a <see cref="T:System.Int16"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Int16"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.UInt16)">
            <summary>
            Writes a <see cref="T:System.UInt16"/> value.
            </summary>
            <param name="value">The <see cref="T:System.UInt16"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Char)">
            <summary>
            Writes a <see cref="T:System.Char"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Char"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Byte)">
            <summary>
            Writes a <see cref="T:System.Byte"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Byte"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.SByte)">
            <summary>
            Writes a <see cref="T:System.SByte"/> value.
            </summary>
            <param name="value">The <see cref="T:System.SByte"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.Decimal)">
            <summary>
            Writes a <see cref="T:System.Decimal"/> value.
            </summary>
            <param name="value">The <see cref="T:System.Decimal"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteValue(System.DateTime)">
            <summary>
            Writes a <see cref="T:System.DateTime"/> value.
            </summary>
            <param name="value">The <see cref="T:System.DateTime"/> value to write.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteComment(System.String)">
            <summary>
            Writes out a comment <code>/*...*/</code> containing the specified text. 
            </summary>
            <param name="text">Text to place inside the comment.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriter.WriteWhitespace(System.String)">
            <summary>
            Writes out the given white space.
            </summary>
            <param name="ws">The string of white space characters.</param>
        </member>
        <member name="P:BigfootSQL.Json.JsonWriter.WriteState">
            <summary>
            Gets the state of the writer.
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonWriter.Formatting">
            <summary>
            Indicates how the output is formatted.
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonWriter.Indentation">
            <summary>
            Gets or sets how many IndentChars to write for each level in the hierarchy when <paramref name="Formatting"/> is set to <c>Formatting.Indented</c>.
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonWriter.QuoteChar">
            <summary>
            Gets or sets which character to use to quote attribute values.
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonWriter.IndentChar">
            <summary>
            Gets or sets which character to use for indenting when <paramref name="Formatting"/> is set to <c>Formatting.Indented</c>.
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonWriter.QuoteName">
            <summary>
            Gets or sets a value indicating whether object names will be surrounded with quotes.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.JsonReaderException">
            <summary>
            The exception thrown when an error occurs while reading Json text.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonReaderException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonReaderException"/> class.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonReaderException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonReaderException"/> class
            with a specified error message.
            </summary>
            <param name="message">The error message that explains the reason for the exception.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonReaderException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonReaderException"/> class
            with a specified error message and a reference to the inner exception that is the cause of this exception.
            </summary>
            <param name="message">The error message that explains the reason for the exception.</param>
            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
        </member>
        <member name="T:BigfootSQL.Json.JsonReader">
            <summary>
            Represents a reader that provides fast, non-cached, forward-only access to serialized Json data.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonReader.#ctor(System.IO.TextReader)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonReader"/> class with the specified <see cref="T:System.IO.TextReader"/>.
            </summary>
            <param name="reader">The <c>TextReader</c> containing the XML data to read.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonReader.Read">
            <summary>
            Reads the next Json token from the stream.
            </summary>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Json.JsonReader.Close">
            <summary>
            Changes the <see cref="T:BigfootSQL.Json.JsonReader.State"/> to Closed. 
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonReader.QuoteChar">
            <summary>
            Gets the quotation mark character used to enclose the value of a string.
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonReader.TokenType">
            <summary>
            Gets the type of the current Json token. 
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonReader.Value">
            <summary>
            Gets the text value of the current Json token.
            </summary>
        </member>
        <member name="P:BigfootSQL.Json.JsonReader.ValueType">
            <summary>
            Gets The Common Language Runtime (CLR) type for the current Json token.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.Converters.XmlNodeConverter.IsNamespaceAttribute(System.String,System.String@)">
            <summary>
            Checks if the attributeName is a namespace attribute.
            </summary>
            <param name="attributeName">Attribute name to test.</param>
            <param name="prefix">The attribute name prefix if it has one, otherwise an empty string.</param>
            <returns>True if attribute name is for a namespace attribute, otherwise false.</returns>
        </member>
        <member name="T:BigfootSQL.Json.JavaScriptConstructor">
            <summary>
            Represents a JavaScript constructor.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.GetListItemType(System.Type)">
            <summary>
            Gets the type of the typed list's items.
            </summary>
            <param name="type">The type.</param>
            <returns>The type of the typed list's items.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.ItemsUnitializedValue``1(System.Collections.Generic.IList{``0})">
            <summary>
            Tests whether the list's items are their unitialized value.
            </summary>
            <param name="list">The list.</param>
            <returns>Whether the list's items are their unitialized value</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.GetMemberUnderlyingType(System.Reflection.MemberInfo)">
            <summary>
            Gets the member's underlying type.
            </summary>
            <param name="member">The member.</param>
            <returns>The underlying type of the member.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.IsIndexedProperty(System.Reflection.MemberInfo)">
            <summary>
            Determines whether the member is an indexed property.
            </summary>
            <param name="member">The member.</param>
            <returns>
            	<c>true</c> if the member is an indexed property; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.IsIndexedProperty(System.Reflection.PropertyInfo)">
            <summary>
            Determines whether the property is an indexed property.
            </summary>
            <param name="property">The property.</param>
            <returns>
            	<c>true</c> if the property is an indexed property; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.GetMemberValue(System.Reflection.MemberInfo,System.Object)">
            <summary>
            Gets the member's value on the object.
            </summary>
            <param name="member">The member.</param>
            <param name="target">The target object.</param>
            <returns>The member's value on the object.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.SetMemberValue(System.Reflection.MemberInfo,System.Object,System.Object)">
            <summary>
            Sets the member's value on the target object.
            </summary>
            <param name="member">The member.</param>
            <param name="target">The target.</param>
            <param name="value">The value.</param>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.CanReadMemberValue(System.Reflection.MemberInfo)">
            <summary>
            Determines whether the specified MemberInfo can be read.
            </summary>
            <param name="member">The MemberInfo to determine whether can be read.</param>
            <returns>
            	<c>true</c> if the specified MemberInfo can be read; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.ReflectionUtils.CanSetMemberValue(System.Reflection.MemberInfo)">
            <summary>
            Determines whether the specified MemberInfo can be set.
            </summary>
            <param name="member">The MemberInfo to determine whether can be set.</param>
            <returns>
            	<c>true</c> if the specified MemberInfo can be set; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="T:BigfootSQL.Validation.ErrorMode">
            <summary>
            Enumeration for setting whether we want one or many errors per field
            to be collected.
            </summary>
        </member>
        <member name="F:BigfootSQL.Validation.ErrorMode.OneErrorPerField">
            <summary>
            Maximum one error per field 
            </summary>
        </member>
        <member name="F:BigfootSQL.Validation.ErrorMode.AllErrors">
            <summary>
            Return all errors found for each field.
            </summary>
        </member>
        <member name="T:BigfootSQL.Validation.ValidatorResultLevel">
            <summary>
            The various levels of validation failure we can have.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.JsonSerializationException">
            <summary>
            The exception thrown when an error occurs during Json serialization or deserialization.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializationException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonSerializationException"/> class.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializationException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonSerializationException"/> class
            with a specified error message.
            </summary>
            <param name="message">The error message that explains the reason for the exception.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializationException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonSerializationException"/> class
            with a specified error message and a reference to the inner exception that is the cause of this exception.
            </summary>
            <param name="message">The error message that explains the reason for the exception.</param>
            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
        </member>
        <member name="T:BigfootSQL.Validation.Validator">
            **************************************************************************
            <summary>
            The main class for the validation library. Create an instance of this per
            set of data that you wish to validate. This class is not threadsafe.
            </summary>
        </member>
        <member name="F:BigfootSQL.Validation.Validator.validatorResults">
            <summary>
            Collection of our validation results.
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.#ctor">
            *****************************************************************
            <summary>
            Default constructor; sets us to collect one error per field and
            generate error messages in English.
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.#ctor(BigfootSQL.Validation.ErrorMode)">
            *****************************************************************
            <summary>
            Constructor for setting both language of generated error messages
            and error collection mode.
            </summary>
            <param name="validationLanguage"></param>
            <param name="mode"></param>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.Clear">
            ******************************************************************
            <summary>
            Clear the validation results and start over.
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.ErrorCount">
            ******************************************************************
            <summary>
            Get the number of validation errors/failures.
            </summary>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.WarningCount">
            ******************************************************************
            <summary>
            Get the number of validation warnings.
            </summary>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.HasErrors">
            ******************************************************************
            <summary>
            Check if we have any validation errors.
            </summary>
            <returns>False if no errors, true if we have errors</returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.HasWarnings">
            ******************************************************************
            <summary>
            Check if we have any validation warnings.
            </summary>
            <returns>False if no warnings, true if we have warnings</returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.Int32,System.String)">
            ******************************************************************
            <summary>
            Start to validate an int.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.UInt32,System.String)">
            ******************************************************************
            <summary>
            Start to validate an uint.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.Int16,System.String)">
            ******************************************************************
            <summary>
            Start to validate a short.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.UInt16,System.String)">
            ******************************************************************
            <summary>
            Start to validate a ushort.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.Int64,System.String)">
            ******************************************************************
            <summary>
            Start to validate a long.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.UInt64,System.String)">
            ******************************************************************
            <summary>
            Start to validate an ulong.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.Byte,System.String)">
            ******************************************************************
            <summary>
            Start to validate a byte.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.SByte,System.String)">
            ******************************************************************
            <summary>
            Start to validate an sbyte.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.Decimal,System.String)">
            ******************************************************************
            <summary>
            Start to validate a decimal.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.Single,System.String)">
            ******************************************************************
            <summary>
            Start to validate a float.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.Double,System.String)">
            ******************************************************************
            <summary>
            Start to validate a double.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.String,System.String)">
            ******************************************************************
            <summary>
            Start to validate a string.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.That(System.DateTime,System.String)">
            ******************************************************************
            <summary>
            Start to validate a DateTime.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.AddValidationError(System.String,System.String,System.Int32)">
            ***********************************************************
            <summary>
            Add a new validation error to the list of validation errors
            </summary>
            <param name="Message"></param>
            <param name="FieldName"></param>
            <param name="errorCode"></param>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.AddValidationError(System.String,System.String,BigfootSQL.Validation.ValidatorResultLevel,System.Int32)">
            ***********************************************************
            <summary>
            Add a new validation error to the list of validation errors
            </summary>
            <param name="Message"></param>
            <param name="FieldName"></param>
            <param name="Level"></param>
            <param name="errorCode"></param>
        </member>
        <member name="M:BigfootSQL.Validation.Validator.LookupLanguageString(System.String,System.Boolean)">
            *********************************************************************
            <summary>
            Looks up a string in the internationalization dictionary.
            </summary>
            <param name="KeyName"></param>
            <param name="Negated"></param>
            <returns></returns>
        </member>
        <member name="P:BigfootSQL.Validation.Validator.ValidatorResults">
            ******************************************************************
            <summary>
            Return a list of the validation results.
            </summary>
        </member>
        <member name="P:BigfootSQL.Validation.Validator.Mode">
            <summary>
            Indicates if we should only collect one error per field name.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.ReferenceLoopHandling">
            <summary>
            Specifies reference loop handling options for the <see cref="T:BigfootSQL.Json.JsonWriter"/>.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.ReferenceLoopHandling.Error">
            <summary>
            Throw a <see cref="T:BigfootSQL.Json.JsonSerializationException"/> when a loop is encountered.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.ReferenceLoopHandling.Ignore">
            <summary>
            Ignore loop references and do not serialize.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.ReferenceLoopHandling.Serialize">
            <summary>
            Serialize loop references.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.JsonSerializer">
            <summary>
            Serializes and deserializes objects into and from the Json format.
            The <see cref="T:BigfootSQL.Json.JsonSerializer"/> enables you to control how objects are encoded into Json.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonSerializer"/> class.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializer.Deserialize(BigfootSQL.Json.JsonReader)">
            <summary>
            Deserializes the Json structure contained by the specified <see cref="T:BigfootSQL.Json.JsonReader"/>.
            </summary>
            <param name="reader">The <see cref="T:BigfootSQL.Json.JsonReader"/> that contains the Json structure to deserialize.</param>
            <returns>The <see cref="T:System.Object"/> being deserialized.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializer.Deserialize(BigfootSQL.Json.JsonReader,System.Type)">
            <summary>
            Deserializes the Json structure contained by the specified <see cref="T:BigfootSQL.Json.JsonReader"/>
            into an instance of the specified type.
            </summary>
            <param name="reader">The type of object to create.</param>
            <param name="objectType">The <see cref="T:System.Type"/> of object being deserialized.</param>
            <returns>The instance of <paramref name="objectType"/> being deserialized.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializer.Serialize(System.IO.TextWriter,System.Object)">
            <summary>
            Serializes the specified <see cref="T:System.Object"/> and writes the Json structure
            to a <c>Stream</c> using the specified <see cref="T:System.IO.TextWriter"/>. 
            </summary>
            <param name="textWriter">The <see cref="T:System.IO.TextWriter"/> used to write the Json structure.</param>
            <param name="value">The <see cref="T:System.Object"/> to serialize.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonSerializer.Serialize(BigfootSQL.Json.JsonWriter,System.Object)">
            <summary>
            Serializes the specified <see cref="T:System.Object"/> and writes the Json structure
            to a <c>Stream</c> using the specified <see cref="T:BigfootSQL.Json.JsonWriter"/>. 
            </summary>
            <param name="jsonWriter">The <see cref="T:BigfootSQL.Json.JsonWriter"/> used to write the Json structure.</param>
            <param name="value">The <see cref="T:System.Object"/> to serialize.</param>
        </member>
        <member name="P:BigfootSQL.Json.JsonSerializer.ReferenceLoopHandling">
            <summary>
            Get or set how reference loops (e.g. a class referencing itself) is handled.
            </summary>
        </member>
        <member name="T:BigfootSQL.Validation.NumericValidator`1">
            ********************************************************************
            <summary>
            Numeric validation handlers.
            </summary>
            <typeparam name="TValue">
            </typeparam>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.#ctor(`0,System.String,BigfootSQL.Validation.Validator)">
            ********************************************************************
            <summary>
            Initializes a new instance of the <see cref="!:NumericValidator"/> class.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <param name="validatorObj"></param>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsLessThanOrEqual(`0,System.String)">
            ********************************************************************
            <summary>
            Checks that the value is less than or equal to the provided value.
            </summary>
            <param name="lessThanValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsLessThanOrEqual(`0)">
            <summary>
            Checks that the value is less than or equal to the provided value.
            </summary>
            <param name="lessThanValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsGreaterThanOrEqual(`0,System.String)">
            ********************************************************************
            <summary>
            Checks that the value is greater than or equal to the provided value.
            </summary>
            <param name="GreaterThanValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsGreaterThanOrEqual(`0)">
            <summary>
            Checks that the value is greater than or equal to the provided value.
            </summary>
            <param name="GreaterThanValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsGreaterThan(`0,System.String)">
            ********************************************************************
            <summary>
            Checks that the value is greater than the provided value.
            </summary>
            <param name="GreaterThanValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsGreaterThan(`0)">
            <summary>
            Checks that the value is greater than the provided value.
            </summary>
            <param name="GreaterThanValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsLessThan(`0,System.String)">
            ********************************************************************
            <summary>
            Checks that the value is less than the provided value.
            </summary>
            <param name="LessThanValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsLessThan(`0)">
            <summary>
            Checks that the value is less than the provided value.
            </summary>
            <param name="LessThanValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.Equals(`0,System.String)">
            ********************************************************************
            <summary>
            Checks that the value is the same as the provided value.
            </summary>
            <param name="EqualValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.Equals(`0)">
            <summary>
            Checks that the value is the same as the provided value.
            </summary>
            <param name="EqualValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.Between(`0,`0,System.String)">
            ********************************************************************
            <summary>
            Checks that the value is within the provided range.
            </summary>
            <param name="StartValue"></param>
            <param name="EndValue"></param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.Between(`0,`0)">
            <summary>
            Checks that the value is within the provided range.
            </summary>
            <param name="StartValue"></param>
            <param name="EndValue"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsZero(System.String)">
            ********************************************************************
            <summary>
            Checks that the value is zero.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.NumericValidator`1.IsZero">
            <summary>
            Checks that the value is zero.
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="T:BigfootSQL.Json.JsonToken">
            <summary>
            Specifies the type of Json token.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.None">
            <summary>
            This is returned by the <see cref="T:BigfootSQL.Json.JsonReader"/> if a <see cref="M:BigfootSQL.Json.JsonReader.Read"/> method has not been called. 
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.StartObject">
            <summary>
            An object start token.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.StartArray">
            <summary>
            An array start token.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.PropertyName">
            <summary>
            An object property name.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Comment">
            <summary>
            A comment.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Integer">
            <summary>
            An interger.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Float">
            <summary>
            A float.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.String">
            <summary>
            A string.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Boolean">
            <summary>
            A boolean.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Null">
            <summary>
            A null token.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Undefined">
            <summary>
            An undefined token.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.EndObject">
            <summary>
            An object end token.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.EndArray">
            <summary>
            An array end token.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Constructor">
            <summary>
            A JavaScript object constructor.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JsonToken.Date">
            <summary>
            A Date.
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.LangCache.FetchItem(System.String)">
            ******************************************************************
            <summary>
            Fetch an item from the language defintion XML files.
            
            Also caches the result
            </summary>
            <param name="StringKey">The string identifier</param>
            <returns>Returns "" if not found</returns>
        </member>
        <member name="M:BigfootSQL.Validation.LangCache.LoadLanguageDefinition">
            *****************************************************************
            <summary>
            Load the entire language definition XML file into the LanguageDict 
            dictionary. LanguageDict acts like a cache/lookup-table for all the 
            language strings.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.JsonWriterException">
            <summary>
            The exception thrown when an error occurs while reading Json text.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriterException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonWriterException"/> class.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriterException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonWriterException"/> class
            with a specified error message.
            </summary>
            <param name="message">The error message that explains the reason for the exception.</param>
        </member>
        <member name="M:BigfootSQL.Json.JsonWriterException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JsonWriterException"/> class
            with a specified error message and a reference to the inner exception that is the cause of this exception.
            </summary>
            <param name="message">The error message that explains the reason for the exception.</param>
            <param name="innerException">The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified.</param>
        </member>
        <member name="T:BigfootSQL.Json.StringBuffer">
            <summary>
            Builds a string. Unlike StringBuilder this class lets you reuse it's internal buffer.
            </summary>
        </member>
        <member name="T:BigfootSQL.Json.JavaScriptObject">
            <summary>
            Represents a JavaScript object.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptObject.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JavaScriptObject"/> class.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptObject.#ctor(BigfootSQL.Json.JavaScriptObject)">
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Json.JavaScriptObject"/> class that
            contains values copied from the specified <see cref="T:BigfootSQL.Json.JavaScriptObject"/>.
            </summary>
            <param name="javaScriptObject">The <see cref="T:BigfootSQL.Json.JavaScriptObject"/> whose elements are copied to the new object.</param>
        </member>
        <member name="T:BigfootSQL.Json.JavaScriptConvert">
            <summary>
            Provides methods for converting between common language runtime types and JavaScript types.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JavaScriptConvert.True">
            <summary>
            Represents JavaScript's boolean value true as a string. This field is read-only.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JavaScriptConvert.False">
            <summary>
            Represents JavaScript's boolean value false as a string. This field is read-only.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JavaScriptConvert.Null">
            <summary>
            Represents JavaScript's null as a string. This field is read-only.
            </summary>
        </member>
        <member name="F:BigfootSQL.Json.JavaScriptConvert.Undefined">
            <summary>
            Represents JavaScript's undefined as a string. This field is read-only.
            </summary>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.DateTime)">
            <summary>
            Converts the <see cref="T:System.DateTime"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.DateTime"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Boolean)">
            <summary>
            Converts the <see cref="T:System.Boolean"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Boolean"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Char)">
            <summary>
            Converts the <see cref="T:System.Char"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Char"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Enum)">
            <summary>
            Converts the <see cref="T:System.Enum"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Enum"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Int32)">
            <summary>
            Converts the <see cref="T:System.Int32"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Int32"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Int16)">
            <summary>
            Converts the <see cref="T:System.Int16"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Int16"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.UInt16)">
            <summary>
            Converts the <see cref="T:System.UInt16"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.UInt16"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.UInt32)">
            <summary>
            Converts the <see cref="T:System.UInt32"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.UInt32"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Int64)">
            <summary>
            Converts the <see cref="T:System.Int64"/>  to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Int64"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.UInt64)">
            <summary>
            Converts the <see cref="T:System.UInt64"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.UInt64"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Single)">
            <summary>
            Converts the <see cref="T:System.Single"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Single"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Double)">
            <summary>
            Converts the <see cref="T:System.Double"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Double"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Byte)">
            <summary>
            Converts the <see cref="T:System.Byte"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Byte"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.SByte)">
            <summary>
            Converts the <see cref="T:System.SByte"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.SByte"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Decimal)">
            <summary>
            Converts the <see cref="T:System.Decimal"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.SByte"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Guid)">
            <summary>
            Converts the <see cref="T:System.Guid"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Guid"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.String)">
            <summary>
            Converts the <see cref="T:System.String"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.String"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.String,System.Char)">
            <summary>
            Converts the <see cref="T:System.String"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <param name="delimter">The string delimiter character.</param>
            <returns>A Json string representation of the <see cref="T:System.String"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.ToString(System.Object)">
            <summary>
            Converts the <see cref="T:System.Object"/> to it's JavaScript string representation.
            </summary>
            <param name="value">The value to convert.</param>
            <returns>A Json string representation of the <see cref="T:System.Object"/>.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.SerializeObject(System.Object)">
            <summary>
            Serializes the specified object to a Json object.
            </summary>
            <param name="value">The object to serialize.</param>
            <returns>A Json string representation of the object.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.DeserializeObject(System.String)">
            <summary>
            Deserializes the specified object to a Json object.
            </summary>
            <param name="value">The object to deserialize.</param>
            <returns>The deserialized object from the Json string.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.DeserializeObject(System.String,System.Type)">
            <summary>
            Deserializes the specified object to a Json object.
            </summary>
            <param name="value">The object to deserialize.</param>
            <param name="type">The <see cref="T:System.Type"/> of object being deserialized.</param>
            <returns>The deserialized object from the Json string.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.DeserializeObject``1(System.String)">
            <summary>
            Deserializes the specified object to a Json object.
            </summary>
            <typeparam name="T">The type of the object to deserialize.</typeparam>
            <param name="value">The object to deserialize.</param>
            <returns>The deserialized object from the Json string.</returns>
        </member>
        <member name="M:BigfootSQL.Json.JavaScriptConvert.DeserializeObject``1(System.String,BigfootSQL.Json.JsonConverter[])">
            <summary>
            Deserializes the specified object to a Json object.
            </summary>
            <typeparam name="T">The type of the object to deserialize.</typeparam>
            <param name="value">The object to deserialize.</param>
            <param name="converters">Converters to use while deserializing.</param>
            <returns>The deserialized object from the Json string.</returns>
        </member>
        <member name="T:BigfootSQL.Validation.StringValidator">
            ********************************************************************
            <summary>
            String validation handler.
            </summary>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.#ctor(System.String,System.String,BigfootSQL.Validation.Validator)">
            ********************************************************************
            <summary>
            Initializes a new instance of the <see cref="T:BigfootSQL.Validation.StringValidator"/> class.
            </summary>
            <param name="value"></param>
            <param name="fieldName"></param>
            <param name="validatorObj"></param>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsEmpty(System.String)">
            ********************************************************************
            <summary>
            Checks if the string is empty.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsEmpty">
            <summary>
            Checks if the string is empty.
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsNotEmpty">
            <summary>
            Checks if the string is not empty.
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsNotEmpty(System.String)">
            <summary>
            Checks if the string is not empty.
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsLength(System.Int32,System.String)">
            ********************************************************************
            <summary>
            Checks if the string has the correct length
            </summary>
            <param name="RequiredLength">The required length.</param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsLength(System.Int32)">
            <summary>
            Checks if the string has the correct length
            </summary>
            <param name="RequiredLength">The required length.</param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsLongerThan(System.Int32,System.String)">
            ********************************************************************
            <summary>
            Checks if the string has more characters than the specified minimum.
            </summary>
            <param name="MinLength">The minimum length.</param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsLongerThan(System.Int32)">
            <summary>
            Checks if the string has more characters than the specified minimum.
            </summary>
            <param name="MinLength">The minimum length.</param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsShorterThan(System.Int32,System.String)">
            ********************************************************************
            <summary>
            Checks that the string has less characters than the provided maximum.
            </summary>
            <param name="MaxLength">The maximum length.</param>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsShorterThan(System.Int32)">
            <summary>
            Checks that the string has less characters than the provided maximum.
            </summary>
            <param name="MaxLength">The maximum length.</param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.MatchRegex(System.String,System.String)">
            ********************************************************************
            <summary>
            Checks that the string matches the supplied regular expression.
            </summary>
            <param name="RegularExpression">The regular expression to check against.</param>
            <param name="ErrorMessage">The Error Message.</param>
            <returns>My instance to allow me to chain multiple validations together </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.MatchRegex(System.String,System.Text.RegularExpressions.RegexOptions,System.String)">
            ********************************************************************
            <summary>
            Checks that the string matches the supplied regular expression.
            </summary>
            <param name="RegularExpression">The regular expression to check against.</param>
            <param name="regexOptions">Any options for the regular expression.</param>
            <param name="ErrorMessage">The Error Message.</param>
            <returns>My instance to allow me to chain multiple validations together </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsEmail(System.String)">
            ********************************************************************
            <summary>
            Checks that the string is an email address.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsEmail">
            <summary>
            Checks that the string is an email address.
            </summary>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsURL(System.String)">
            ********************************************************************
            <summary>
            Checks that the string is a URL.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsURL">
            <summary>
            Checks that the string is a URL.
            </summary>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsDate(System.String)">
            ********************************************************************
            <summary>
            Checks if the string can be parsed as a date under the current locale.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsDate">
            <summary>
            Checks if the string can be parsed as a date under the current locale.
            </summary>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsInteger(System.String)">
            ********************************************************************
            <summary>
            Checks if the string can be parsed as an integer.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsInteger">
            <summary>
            Checks if the string can be parsed as an integer.
            </summary>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsDecimal(System.String)">
            ********************************************************************
            <summary>
            Checks if the string can be parsed as a deciaml under the current locale.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsDecimal">
            <summary>
            Checks if the string can be parsed as a deciaml under the current locale.
            </summary>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.HasALengthBetween(System.Int32,System.Int32,System.String)">
            ********************************************************************
            <summary>
            Checks that the length of the string is within the provided minimum
            and maximum length limits.
            </summary>
            <param name="MinLength"></param>
            <param name="MaxLength"></param>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.HasALengthBetween(System.Int32,System.Int32)">
            <summary>
            Checks that the length of the string is within the provided minimum
            and maximum length limits.
            </summary>
            <param name="MinLength"></param>
            <param name="MaxLength"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.StartsWith(System.String,System.String)">
            ********************************************************************
            <summary>
            Checks that the string starts with StartValue.
            </summary>
            <param name="StartValue"></param>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.StartsWith(System.String)">
            <summary>
            Checks that the string starts with StartValue.
            </summary>
            <param name="StartValue"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.EndsWith(System.String,System.String)">
            ********************************************************************
            <summary>
            Checks that the string ends with EndValue.
            </summary>
            <param name="EndValue"></param>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.EndsWith(System.String)">
            <summary>
            Checks that the string ends with EndValue.
            </summary>
            <param name="EndValue"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.Contains(System.String,System.String)">
            ********************************************************************
            <summary>
            Checks that the string contains the specified CompareValue.
            </summary>
            <param name="CompareValue"></param>
            <param name="ErrorMessage"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.Contains(System.String)">
            <summary>
            Checks that the string contains the specified CompareValue.
            </summary>
            <param name="CompareValue"></param>
            <returns>
            My instance to allow me to chain multiple validations together
            </returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsCreditCard">
            <summary>
            Checks if the string is a valid credit card.
            </summary>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Validation.StringValidator.IsCreditCard(System.String)">
            ********************************************************************
            <summary>
            Checks if the string is a valid credit card.
            </summary>
            <param name="ErrorMessage"></param>
            <returns>My instance to allow me to chain multiple validations together</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.ContainsWhiteSpace(System.String)">
            <summary>
            Determines whether the string contains white space.
            </summary>
            <param name="s">The string to test for white space.</param>
            <returns>
            	<c>true</c> if the string contains white space; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.IsWhiteSpace(System.String)">
            <summary>
            Determines whether the string is all white space. Empty string will return false.
            </summary>
            <param name="s">The string to test whether it is all white space.</param>
            <returns>
            	<c>true</c> if the string is all white space; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.EnsureEndsWith(System.String,System.String)">
            <summary>
            Ensures the target string ends with the specified string.
            </summary>
            <param name="target">The target.</param>
            <param name="value">The value.</param>
            <returns>The target string with the value string at the end.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.IsNullOrEmpty(System.Data.SqlTypes.SqlString)">
            <summary>
            Determines whether the SqlString is null or empty.
            </summary>
            <param name="s">The string.</param>
            <returns>
            	<c>true</c> if the SqlString is null or empty; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.IfNotNullOrEmpty(System.String,System.Action{System.String})">
            <summary>
            Perform an action if the string is not null or empty.
            </summary>
            <param name="value">The value.</param>
            <param name="action">The action to perform.</param>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.Indent(System.String,System.Int32)">
            <summary>
            Indents the specified string.
            </summary>
            <param name="s">The string to indent.</param>
            <param name="indentation">The number of characters to indent by.</param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.Indent(System.String,System.Int32,System.Char)">
            <summary>
            Indents the specified string.
            </summary>
            <param name="s">The string to indent.</param>
            <param name="indentation">The number of characters to indent by.</param>
            <param name="indentChar">The indent character.</param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.NumberLines(System.String)">
            <summary>
            Numbers the lines.
            </summary>
            <param name="s">The string to number.</param>
            <returns></returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.StringUtils.NullEmptyString(System.String)">
            <summary>
            Nulls an empty string.
            </summary>
            <param name="s">The string.</param>
            <returns>Null if the string was null, otherwise the string unchanged.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.CollectionUtils.IsNullOrEmpty(System.Collections.ICollection)">
            <summary>
            Determines whether the collection is null or empty.
            </summary>
            <param name="collection">The collection.</param>
            <returns>
            	<c>true</c> if the collection is null or empty; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.CollectionUtils.IsNullOrEmpty``1(System.Collections.Generic.ICollection{``0})">
            <summary>
            Determines whether the collection is null or empty.
            </summary>
            <param name="collection">The collection.</param>
            <returns>
            	<c>true</c> if the collection is null or empty; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.CollectionUtils.IsNullOrEmptyOrDefault``1(System.Collections.Generic.IList{``0})">
            <summary>
            Determines whether the collection is null, empty or its contents are uninitialized values.
            </summary>
            <param name="list">The list.</param>
            <returns>
            	<c>true</c> if the collection is null or empty or its contents are uninitialized values; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.CollectionUtils.Slice``1(System.Collections.Generic.IList{``0},System.Nullable{System.Int32},System.Nullable{System.Int32})">
            <summary>
            Makes a slice of the specified list in between the start and end indexes.
            </summary>
            <param name="list">The list.</param>
            <param name="start">The start index.</param>
            <param name="end">The end index.</param>
            <returns>A slice of the list.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.CollectionUtils.Slice``1(System.Collections.Generic.IList{``0},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Nullable{System.Int32})">
            <summary>
            Makes a slice of the specified list in between the start and end indexes,
            getting every so many items based upon the step.
            </summary>
            <param name="list">The list.</param>
            <param name="start">The start index.</param>
            <param name="end">The end index.</param>
            <param name="step">The step.</param>
            <returns>A slice of the list.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.CollectionUtils.GroupBy``2(System.Collections.Generic.ICollection{``1},BigfootSQL.Json.Utilities.Func{``1,``0})">
            <summary>
            Group the collection using a function which returns the key.
            </summary>
            <param name="source">The source collection to group.</param>
            <param name="keySelector">The key selector.</param>
            <returns>A Dictionary with each key relating to a list of objects in a list grouped under it.</returns>
        </member>
        <member name="M:BigfootSQL.Json.Utilities.CollectionUtils.AddRange``1(System.Collections.Generic.IList{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Adds the elements of the specified collection to the specified generic IList.
            </summary>
            <param name="initial">The list to add to.</param>
            <param name="collection">The collection of elements to add.</param>
        </member>
    </members>
</doc>
